package DARP;
import java.util.LinkedList;
import java.util.List;


//public class CriacaoRotas {
//
//	Data data = Data.getPRVData();
//	LinkedList<int[]> lista;
//	LinkedList<FuncaoObjetivo> listaFO;
//	int quantidadeVeiculos, quantidadeDePontos;
//
//	int[] id = data.getId(), veic = data.getVeiculos();
//	float[] cordx = data.getCoordX();
//	float[][] matriz = data.getMatriz();
//	int[] capacidadeVeiculo = data.getCapacidadeDosVeiculos();
//	//=========== FO ============
//	float funcaoObjetivo;
//	float w0,w1,w2,w3,w4,b0,b1,b2,b3,b4;
//	//Data data;
//	float[] R_TempoMaximo_Rota, W_TempoMaximo_Espera, e, l;
//	float[][] matrizDistancia = data.getMatriz(), t;
//	int qntVeiculos = data.getQuantidadeDeVeiculos(), qntPontos = data.getQuantidadeDePontosDeColetas();
//	int[][][] x = new int[qntVeiculos][qntPontos][qntPontos];
//	int[] garagemInicial = data.getGaragensIniciais(), garagemFinal = data.getGaragensFinais();
//
//	
//	
//	/**
//	 * Inicializa as Rotas, criando para cada veiculo uma rota vazia, constando somente as garagens inicial e final
//	 * @param veiculos
//	 * @param garagemInicial
//	 * @param garagemFinal
//	 * @return
//	 */
//	public LinkedList<int[]> InicializaRotas(int[] veiculos, int[] garagemInicial, int[] garagemFinal){
//
//		int contVeiculos = 0;
//		int numRotas = veiculos.length;
//		lista = new LinkedList<int[]>();
//
//		int qntveiculos = quantidadeVeiculos;
//		while(contVeiculos  < veiculos.length){//Cria rota para cada veiculo
//			int[] rota = new int[2*capacidadeVeiculo[contVeiculos]];//Vetor com os ids das requisicoes e das variaveis
//			for (int i = 0; i < rota.length; i++) {
//				rota[i] = -1;
//			}
//			rota[0]=garagemInicial[contVeiculos];
//			rota[2*capacidadeVeiculo[contVeiculos]-1] = garagemFinal[contVeiculos];
//			//			for (int i = 0; i < rota.length; i++) {
//			//				System.out.println("Rota Vaga :"+i+"=>"+rota[i]);
//			//			}
//			
//			lista.add(contVeiculos, rota);
//			FuncaoObjetivo fo = new FuncaoObjetivo(data);
//			listaFO.add(fo);
//			System.out.println("Cria classe Fo");
//			
////			System.out.println("Calcula Fo");
//			//fo.calculaFO();
//			
//			
//			contVeiculos++;
//		}
//		
//		
//		return lista;
//	}
//
//	public LinkedList SolucaoInicia1(int[] veiculos,int[] garagemInicial, int[] garagemFinal, 
//			float[][] matrizDistancia){
//		//		LinkedList<int[]> list = 
//		InicializaRotas(veiculos, garagemInicial, garagemFinal);//Inicializa Rotas [G-, G+]
//		quantidadeDePontos = data.getQuantidadeDePontosDeColetas();
//		quantidadeVeiculos = data.getQuantidadeDeVeiculos();
//		//System.out.println("Tamanho da lista de rotas: " + list.toString());
//		//		int quantidadeVeiculos = qntVeiculos;
//		int cont= 0, numMaxIteracoes = 10, rotas = 0;
//
//		while((data.getNumOfVisited() < data.getQuantidadeDePontosDeColetas()) || 
//				(cont < numMaxIteracoes)||
//				(data.getNumOfVisited() > data.getQuantidadeDePontosDeColetas()-1)){
//
//			cont++;
//			int rotaRandomica = (int) ((Math.random() * quantidadeVeiculos));
//
//			int[] rotaAtual = lista.get(rotaRandomica);
//			//			if(rotaAtual.length > capacidadeVeiculo[rotaRandomica]){
//			//				if(rotas >= qntVeiculos)//TODO VERIFICAR ISTO AQUI!
//			//					break;
//			//				else
//			//					continue;
//			//			}
//
//			int adidiconarRequisicao = data.retornaMenorDistacia(garagemInicial[rotaRandomica],matrizDistancia);
//			if (adidiconarRequisicao == 999) {
//				break;
//			}
//			int[] rotaTemp;
//			rotaTemp = rotaAtual;
//			System.out.println("Rota :"+rotaRandomica);
//			for (int i = 0; i < rotaTemp.length/2; i++) {
//				if(rotaTemp[i] == -1 ){
//					//System.out.println("Inserindo no local: "+i+"e no: "+(i+ (rotaTemp.length/2)-1));
//					rotaTemp[i] = adidiconarRequisicao;//Embarque
//					rotaTemp[i+ (rotaTemp.length/2)-1] = (adidiconarRequisicao - 1 + data.getId().length/2);//Respectivo Desembarque
//					break;
//				}
//
//			}
//			////if (VerificaSeViolaRestricoes()) {
//			lista.remove(rotaRandomica);
//			lista.add(rotaRandomica, rotaTemp);
//			data.setRequisicoesVisitadas(adidiconarRequisicao, (adidiconarRequisicao - 1 + data.getId().length/2));
//			//}
//			System.out.println(lista.toString());
//			rotas++;
//		}//Fim While
//
//		int[] rotaRemanescentes = data.getNotVisited();
//		//System.out.println("Rotas Finais: "+list.toString());
//
//		lista.add(rotaRemanescentes);
//		System.out.println("Rotas Finais (Solucao Inicial): "+lista.toString()+" Tamanho : "+ lista.size());
//
//		return lista;
//	}//TODO FAZER UMA LISTA COM O RESTANTE DAS REQUISICOES, A LISTA DUMMY
//
//
//
//	//	private int retornaMenorDistacia(int elementoComparado, float[][] matrizDistancia) {
//	//		// TODO VERIFICAR OS 2 ENTRADA E SAIDA (METADE DO N)
//	//		float min = Integer.MAX_VALUE;
//	//		int cont = 0,j =0, elementoRetornado = 0;
//	//		System.out.println("Elemento comparado no retornaMenorDist"+ elementoComparado);
//	//		if(elementoComparado < )
//	//		while(cont < matrizDistancia.length){
//	//			if (min < matrizDistancia[elementoComparado][j]){
//	//				min =  matrizDistancia[elementoComparado][j];
//	//				elementoRetornado = j;
//	//			}
//	//			cont++;
//	//		}
//	//		return elementoRetornado;
//	//	}
//
//	private boolean VerificaSeViolaRestricoes() {
//		//TODO VERIFICAR A FUNCAO OBJETIVO
//		return true;
//	}
//
//
//
//	/*
//	 * ========================  ILS MRD =========================== 
//	 */
//	public LinkedList ILS(int maxIter, int maxIterILS, int kpMax, int delta){
//
//		LinkedList<int[]> so = SolucaoInicia1(veic, garagemInicial, garagemFinal, matriz),
//		s_linha = null, s_duaslinhas ;//SOLUCAO INICIAL
//		LinkedList<int[]> s = MRD(so, maxIter);
//		int kp = 0;
//		int iter = 0, melhorIter = 0;
//		while (kp < kpMax){
//			iter = melhorIter;
//			while(iter < maxIter){
//				iter = iter + 1;
//				s_linha = pertubacao(s_linha);
//				s_duaslinhas = MRD(so, maxIterILS);
//				if (calculaFO(s_linha) < calculaFO(s_duaslinhas)){
//					s_linha = s_duaslinhas;
//					melhorIter = iter;
//					kp = 0;
//				}
//			}
//			kp = kp + delta;
//		}
//
//		return s_linha;
//	}
//	private int calculaFO(LinkedList<int[]> sLinha) {
//		int[] rotaDaVez;
//		for (int k = 0; k < sLinha.size(); k++) {
//			rotaDaVez = sLinha.get(k);
//			for (int i = 0; i < rotaDaVez.length; i++) {
//				FuncaoObjetivo fo = listaFO.get(i);
//				fo.calculaFO(rotaDaVez);
//			}
//		}
//		
//		
//		return 0;
//	}
//
//	/*
//	 * ========================  ILS MRD =========================== 
//	 */
//	private LinkedList<LinkedList> pertubacao(LinkedList<LinkedList> sLinha) {
//		// TODO Auto-generated method stub
//		return null;
//	}
//
//	private int FO(LinkedList<LinkedList> sLinha) {
//		// TODO Auto-generated method stub
//		validaRestricoes();
//		return 0;
//	}
//
//	private void validaRestricoes() {
//		// TODO Auto-generated method stub
//
//	}
//
//	public LinkedList<LinkedList> MRD(LinkedList<LinkedList> so, int maxIter){
//
//		int iter = 0;
//		while(iter < maxIter){
//			iter = iter + 1;
//			LinkedList<LinkedList> s_linha = GeraAleatoriamente (so);
//			if(FO(s_linha) < FO(so)){
//				so = s_linha;
//				iter = 0;
//			}
//		}
//
//		return null;
//	}
//
//	private LinkedList<LinkedList> GeraAleatoriamente(LinkedList<LinkedList> so) {
//		// TODO Auto-generated method stub
//		return null;
//	}
//
//	//	float ILS(int n, int *s, float **d,
//	//	          int vezesnivel, // nro de vezes sem melhora em um dado nivel
//	//	          int ILSmax)  // nro de niveis sem melhora
//	//	{
//	//	  int i, j, nivel, iter, MelhorIter;
//	//	  int *s_2l;
//	//	  float fo, fo_2l;
//	//
//	//	  s_2l = cria_vetor(n);
//	//	  fo = descida(n,s,d);
//	//	  iter = MelhorIter = 0;
//	//	  nivel = 1;
//	//	  while (iter - MelhorIter < ILSmax){
//	//	    iter++;
//	//	    // s_2l <- s
//	//	    atualiza_vetor(s_2l,s,n);
//	//	    int vezes = 0;
//	//	    while (vezes < vezesnivel){
//	//	       int ntrocasmax = nivel + 1;
//	//	       int ntrocas = 0;
//	//	       atualiza_vetor(s_2l,s,n);
//	//	       fo_2l = fo;
//	//	       while (ntrocas < ntrocasmax){
//	//	         ntrocas++;
//	//	         i = random(n);
//	//	         do{
//	//	           j = random(n);
//	//	         }while (i == j);
//	//	         int aux;
//	//	         aux = s_2l[i];
//	//	         s_2l[i] = s_2l[j];
//	//	         s_2l[j] = aux;
//	//	       } // fim while ntrocasmax
//	//	       fo_2l = descida(n,s_2l,d);
//	//	       if (fo_2l < fo){
//	//	         fo = fo_2l;
//	//	         atualiza_vetor(s,s_2l,n);
//	//	         vezes = 0;
//	//	         nivel = 1;
//	//	         MelhorIter = iter;
//	//	         printf("fo = %12.4f \n", fo);
//	//	       }
//	//	       vezes++;
//	//	    } // fim while vezesnivel
//	//	    nivel++;
//	//	    printf("Aumentando o nivel perturbacao para %2d \n",nivel);
//	//	  } // fim while
//	//
//	//	  libera_vetor(s_2l);
//	//	  return fo;
//	//	}
//
//
//
//	public void Mainzao(){
//		//		ILS(100, 100, 100, 1);
//		data = Data.getPRVData();
//		int[] id = data.getId(), veic = data.getVeiculos();
//		float[] cordx = data.getCoordX();
//		float[][] matriz = data.getMatriz();
//
//		int[] garagemInicial = data.getGaragensIniciais(), garagemFinal = data.getGaragensFinais();
//		SolucaoInicia1(veic, garagemInicial, garagemFinal, matriz);
//		
//		System.out.println("Calculou Fo");
//		//InicializaRotas(veic, garagemInicial, garagemFinal);
//		//LinkedList list = (LinkedList) lista.getFirst();
//
////		float fo = calculaFO(lista);
//		//System.out.println("FO: "+fo);
//		System.out.println(lista.toString()+"Teste "+lista);
//		for (int i = 0; i < qntVeiculos; i++) {
//			System.out.println("Rota "+i);
//			int[] rota = lista.get(i);
//			for (int j = 0; j < rota.length; j++){
//				System.out.println(rota[j]);
//			}
//		}
//		//System.out.println("Veiculos " + dt.getVeiculos());
//		//InicializaRotas(dt.getVeiculos(), dt.getGaratensIniciais(), dt.getGaratensFinais());
//		//System.out.println("Do main: "+);
//
//	}
//
//
//
//}
///**
//package DARP;
//import java.util.LinkedList;
//import java.util.List;


public class CriacaoRotas {

	Data data = Data.getPRVData();
	LinkedList<int[]> lista;
	LinkedList<FuncaoObjetivo> listaFO;
	int quantidadeVeiculos, quantidadeDePontos;

	int[] id = data.getId(), veic = data.getVeiculos();
	float[] cordx = data.getCoordX();
	float[][] matriz = data.getMatriz();
	int[] capacidadeVeiculo = data.getCapacidadeDosVeiculos();
	//=========== FO ============
	float funcaoObjetivo;
	float w0, w1, w2, w3, w4, b0, b1, b2, b3, b4, velocidadeMedia = 20;
	//Data data;
	float[] R_TempoMaximo_Rota, W_TempoMaximo_Espera, e = data.getInicioJanela(), l = data.getFimJanela();
	float[][] matrizDistancia = data.getMatriz(), t;
	int qntVeiculos = data.getQuantidadeDeVeiculos(), qntPontos = data.getQuantidadeDePontosDeColetas();
	int[][][] x = new int[qntVeiculos][qntPontos][qntPontos];
	int[] garagemInicial = data.getGaragensIniciais(), garagemFinal = data.getGaragensFinais();

	float[] A = new float[qntPontos], 
	B = new float[qntPontos],
	D = new float[qntPontos],
	R = new float[qntPontos],
	W = new float[qntPontos],
	T = new float[qntPontos],
	Q = new float[qntPontos],
	s = new float[qntPontos],
	q = new float[qntPontos];



	/**
	 * Inicializa as Rotas, criando para cada veiculo uma rota vazia, constando somente as garagens inicial e final
	 * @param veiculos
	 * @param garagemInicial
	 * @param garagemFinal
	 * @return
	 */
	public LinkedList<int[]> InicializaRotas(int[] veiculos, int[] garagemInicial, int[] garagemFinal){

		int contVeiculos = 0;
		int numRotas = veiculos.length;
		lista = new LinkedList<int[]>();

		int qntveiculos = quantidadeVeiculos;
		while(contVeiculos  < veiculos.length){//Cria rota para cada veiculo
			int[] rota = new int[2*capacidadeVeiculo[contVeiculos]];//Vetor com os ids das requisicoes e das variaveis
			for (int i = 0; i < rota.length; i++) {
				rota[i] = -1;
			}
			rota[0]=garagemInicial[contVeiculos];
			rota[2*capacidadeVeiculo[contVeiculos]-1] = garagemFinal[contVeiculos];
			//			for (int i = 0; i < rota.length; i++) {
			//				System.out.println("Rota Vaga :"+i+"=>"+rota[i]);
			//			}

			lista.add(contVeiculos, rota);
			FuncaoObjetivo fo = new FuncaoObjetivo(data);
			listaFO.add(fo);
			System.out.println("Cria classe Fo");

			//			System.out.println("Calcula Fo");
			//fo.calculaFO();


			contVeiculos++;
		}


		return lista;
	}

	public LinkedList SolucaoInicia1(int[] veiculos,int[] garagemInicial, int[] garagemFinal, 
			float[][] matrizDistancia){
		//		LinkedList<int[]> list = 
		InicializaRotas(veiculos, garagemInicial, garagemFinal);//Inicializa Rotas [G-, G+]
		quantidadeDePontos = data.getQuantidadeDePontosDeColetas();
		quantidadeVeiculos = data.getQuantidadeDeVeiculos();
		//System.out.println("Tamanho da lista de rotas: " + list.toString());
		//		int quantidadeVeiculos = qntVeiculos;
		int cont= 0, numMaxIteracoes = 10, rotas = 0;

		while((data.getNumOfVisited() < data.getQuantidadeDePontosDeColetas()) || 
				(cont < numMaxIteracoes)||
				(data.getNumOfVisited() > data.getQuantidadeDePontosDeColetas()-1)){

			cont++;
			int rotaRandomica = (int) ((Math.random() * quantidadeVeiculos));

			int[] rotaAtual = lista.get(rotaRandomica);
			//			if(rotaAtual.length > capacidadeVeiculo[rotaRandomica]){
			//				if(rotas >= qntVeiculos)//TODO VERIFICAR ISTO AQUI!
			//					break;
			//				else
			//					continue;
			//			}

			int adidiconarRequisicao = data.retornaMenorDistacia(garagemInicial[rotaRandomica],matrizDistancia);
			if (adidiconarRequisicao == 999) {
				break;
			}
			int[] rotaTemp;
			rotaTemp = rotaAtual;
			System.out.println("Rota :"+rotaRandomica);
			for (int i = 0; i < rotaTemp.length/2; i++) {
				if(rotaTemp[i] == -1 ){
					//System.out.println("Inserindo no local: "+i+"e no: "+(i+ (rotaTemp.length/2)-1));
					rotaTemp[i] = adidiconarRequisicao;//Embarque
					rotaTemp[i+ (rotaTemp.length/2)-1] = (adidiconarRequisicao - 1 + data.getId().length/2);//Respectivo Desembarque
					break;
				}

			}
			////if (VerificaSeViolaRestricoes()) {
			lista.remove(rotaRandomica);
			lista.add(rotaRandomica, rotaTemp);
			data.setRequisicoesVisitadas(adidiconarRequisicao, (adidiconarRequisicao - 1 + data.getId().length/2));
			//}
			System.out.println(lista.toString());
			rotas++;
		}//Fim While

		int[] rotaRemanescentes = data.getNotVisited();
		//System.out.println("Rotas Finais: "+list.toString());

		lista.add(rotaRemanescentes);
		System.out.println("Rotas Finais (Solucao Inicial): "+lista.toString()+" Tamanho : "+ lista.size());

		return lista;
	}//TODO FAZER UMA LISTA COM O RESTANTE DAS REQUISICOES, A LISTA DUMMY



	//	private int retornaMenorDistacia(int elementoComparado, float[][] matrizDistancia) {
	//		// TODO VERIFICAR OS 2 ENTRADA E SAIDA (METADE DO N)
	//		float min = Integer.MAX_VALUE;
	//		int cont = 0,j =0, elementoRetornado = 0;
	//		System.out.println("Elemento comparado no retornaMenorDist"+ elementoComparado);
	//		if(elementoComparado < )
	//		while(cont < matrizDistancia.length){
	//			if (min < matrizDistancia[elementoComparado][j]){
	//				min =  matrizDistancia[elementoComparado][j];
	//				elementoRetornado = j;
	//			}
	//			cont++;
	//		}
	//		return elementoRetornado;
	//	}

	private boolean VerificaSeViolaRestricoes() {
		//TODO VERIFICAR A FUNCAO OBJETIVO
		return true;
	}



	/*
	 * ========================  ILS MRD =========================== 
	 */
	public LinkedList ILS(int maxIter, int maxIterILS, int kpMax, int delta){

		LinkedList<int[]> so = SolucaoInicia1(veic, garagemInicial, garagemFinal, matriz),
		s_linha = null, s_duaslinhas ;//SOLUCAO INICIAL
		LinkedList<int[]> s = MRD(so, maxIter);
		int kp = 0;
		int iter = 0, melhorIter = 0;
		while (kp < kpMax){
			iter = melhorIter;
			while(iter < maxIter){
				iter = iter + 1;
				s_linha = pertubacao(s_linha);
				s_duaslinhas = MRD(so, maxIterILS);
				if (calculaFO(s_linha) < calculaFO(s_duaslinhas)){
					s_linha = s_duaslinhas;
					melhorIter = iter;
					kp = 0;
				}
			}
			kp = kp + delta;
		}

		return s_linha;
	}

	/*
	 * ========================  ILS MRD =========================== 
	 */
	private LinkedList<LinkedList> pertubacao(LinkedList<LinkedList> sLinha) {
		// TODO Auto-generated method stub
		return null;
	}

	private int FO(LinkedList<LinkedList> sLinha) {
		// TODO Auto-generated method stub
		validaRestricoes();
		return 0;
	}

	private void validaRestricoes() {
		// TODO Auto-generated method stub

	}

	public LinkedList<LinkedList> MRD(LinkedList<LinkedList> so, int maxIter){

		int iter = 0;
		while(iter < maxIter){
			iter = iter + 1;
			LinkedList<LinkedList> s_linha = GeraAleatoriamente (so);
			if(FO(s_linha) < FO(so)){
				so = s_linha;
				iter = 0;
			}
		}

		return null;
	}

	private LinkedList<LinkedList> GeraAleatoriamente(LinkedList<LinkedList> so) {
		// TODO Auto-generated method stub
		return null;
	}

	//	float ILS(int n, int *s, float **d,
	//	          int vezesnivel, // nro de vezes sem melhora em um dado nivel
	//	          int ILSmax)  // nro de niveis sem melhora
	//	{
	//	  int i, j, nivel, iter, MelhorIter;
	//	  int *s_2l;
	//	  float fo, fo_2l;
	//
	//	  s_2l = cria_vetor(n);
	//	  fo = descida(n,s,d);
	//	  iter = MelhorIter = 0;
	//	  nivel = 1;
	//	  while (iter - MelhorIter < ILSmax){
	//	    iter++;
	//	    // s_2l <- s
	//	    atualiza_vetor(s_2l,s,n);
	//	    int vezes = 0;
	//	    while (vezes < vezesnivel){
	//	       int ntrocasmax = nivel + 1;
	//	       int ntrocas = 0;
	//	       atualiza_vetor(s_2l,s,n);
	//	       fo_2l = fo;
	//	       while (ntrocas < ntrocasmax){
	//	         ntrocas++;
	//	         i = random(n);
	//	         do{
	//	           j = random(n);
	//	         }while (i == j);
	//	         int aux;
	//	         aux = s_2l[i];
	//	         s_2l[i] = s_2l[j];
	//	         s_2l[j] = aux;
	//	       } // fim while ntrocasmax
	//	       fo_2l = descida(n,s_2l,d);
	//	       if (fo_2l < fo){
	//	         fo = fo_2l;
	//	         atualiza_vetor(s,s_2l,n);
	//	         vezes = 0;
	//	         nivel = 1;
	//	         MelhorIter = iter;
	//	         printf("fo = %12.4f \n", fo);
	//	       }
	//	       vezes++;
	//	    } // fim while vezesnivel
	//	    nivel++;
	//	    printf("Aumentando o nivel perturbacao para %2d \n",nivel);
	//	  } // fim while
	//
	//	  libera_vetor(s_2l);
	//	  return fo;
	//	}



	public void Mainzao(){
		//		ILS(100, 100, 100, 1);
		data = Data.getPRVData();
		int[] id = data.getId(), veic = data.getVeiculos();
		float[] cordx = data.getCoordX();
		float[][] matriz = data.getMatriz();

		int[] garagemInicial = data.getGaragensIniciais(), garagemFinal = data.getGaragensFinais();
		SolucaoInicia1(veic, garagemInicial, garagemFinal, matriz);

		System.out.println("Calculou Fo");
		//InicializaRotas(veic, garagemInicial, garagemFinal);
		//LinkedList list = (LinkedList) lista.getFirst();

		//		float fo = calculaFO(lista);
		//System.out.println("FO: "+fo);
		System.out.println(lista.toString()+"Teste "+lista);
		for (int i = 0; i < qntVeiculos; i++) {
			System.out.println("Rota "+i);
			int[] rota = lista.get(i);
			for (int j = 0; j < rota.length; j++){
				System.out.println(rota[j]);
			}
		}
		//System.out.println("Veiculos " + dt.getVeiculos());
		//InicializaRotas(dt.getVeiculos(), dt.getGaratensIniciais(), dt.getGaratensFinais());
		//System.out.println("Do main: "+);

	}

	public LinkedList<int[]> heuristicaDeProgramacao(LinkedList<int[]> listaHP) {
		int[] rotaDaVez;
		
		D[0] = B[0] = e[0];
		
		calcularVariaveis();
		float[] F = new float[qntVeiculos];
		F[0] = calcularFO();
		float Wp = Wp();
		B[0] = e[0] + Math.min(F[0], Wp);
		D[0] = B[0];
		calcularR();
		for (int v = 0; v < listaHP.size(); v++) {
			F[v]= calcularFO();
			Wp = Wp();
			B[v] = B[v] + Math.min(F[v], Wp);
			D[v] = B[v] + s[v];
			W[v] = B[v] - A[v];
			atualizarVariaveis(v);
			calcularR(v);
		}
		return listaHP;
		
		//...
	}

	private void calcularR(int v) {
		for (int i = v; i < qntPontos/2; i++) {//Vi i pertence a  P
			R[i] = B[(qntPontos/2)+i] - W[i];
		}
		
	}

	public void calcularVariaveis(){
		int[] rotaAtual;
		for(int k = 0; k < lista.size(); k++){ //para obtermos x^k_{i,j}
			rotaAtual = lista.get(k);
			for(int i = 0; i < rotaAtual.length; i++){
				// if(){
				B[i+1] = B[i] + s[i] + matrizDistancia[i][i+1]/velocidadeMedia + W[i+1];//Definir  Velocidade Media
				Q[i+1] = Q[i] + q[i+1];
				// }
				if(i > 0){ //P u U u G+
					A[i] = B[i] - W[i];
				}
				if(i < rotaAtual.length){ //P u U u G-
					D[i] = B[i] + s[i];
				}
				if(i < qntPontos/2){
					R[i] = B[(qntPontos/2)+i] - W[i];
				}

			}
		}

	}

	private void atualizarVariaveis(int v) {
		int[] rotaAtual;
		for(int k = 0; k < lista.size(); k++){ //para obtermos x^k_{i,j}
			rotaAtual = lista.get(k);
			for(int i = v; i < rotaAtual.length; i++){
				// if(){
				B[i+1] = B[i] + s[i] + matrizDistancia[i][i+1]/velocidadeMedia + W[i+1];//Definir  Velocidade Media
				Q[i+1] = Q[i] + q[i+1];
				// }
				if(i > 0){ //P u U u G+
					A[i] = B[i] - W[i];
				}
				if(i < rotaAtual.length){ //P u U u G-
					D[i] = B[i] + s[i];
				}
				if(i < qntPontos/2){
					R[i] = B[(qntPontos/2)+i] - W[i];
				}

			}
		}
	}

	private void calcularR() {
		for (int i = 1; i < qntPontos/2; i++) {//Vi i pertence a  P
			R[i] = B[(qntPontos/2)+i] - W[i];
		}

	}

	public float Wp(){
		float soma = 0;
		for (int p = 0; p < qntPontos; p++) {
			soma += W[p];
		}
		return soma;
	}




	private float calcularFO() {
		int[] rotaDaVez;
		for (int k = 0; k < sLinha.size(); k++) {
			rotaDaVez = sLinha.get(k);
			for (int i = 0; i < rotaDaVez.length; i++) {
				FuncaoObjetivo fo = listaFO.get(i);
				fo.calculaFO(rotaDaVez);
			}
		}

		return 0;
	}


	//	private void calcularVariaveis(float[] a2, float[] b5, float[] w5,
	//			float[] d2, float[] q2) {
	//		for (int r = 0; r < lista.size(); r++) {
	//			for (int k = 0; k < lista.size(); k++) {
	//				if(){
	//					B[r+1] = B[r]+s[r]+t[r+1][r]+W[r+1];
	//					Q[r+1] = Q[r]+q[r+1];
	//				}
	//				if(){
	//					A[r] = B[r] - W[r];
	//				}
	//				if(){
	//					D[r] = B[r] + s[r];
	//				}
	//				if(){
	//					R[r] = B[(qntPontos/2)+ r] - D[r];
	//				}
	//			}
	//		}
	//	}		


}
